Poza testami jednostkowymi: dogłębne spojrzenie na testowanie oparte na właściwościach z użyciem biblioteki Hypothesis w Pythonie

W świecie rozwoju oprogramowania testowanie jest podstawą jakości. Od dziesięcioleci dominującym paradygmatem jest testowanie oparte na przykładach. Skrupulatnie tworzymy dane wejściowe, definiujemy oczekiwane dane wyjściowe i piszemy asercje, aby sprawdzić, czy nasz kod zachowuje się zgodnie z planem. To podejście, spotykane w frameworkach takich jak unittest i pytest, jest potężne i niezbędne. Ale co, jeśli powiem ci, że istnieje podejście uzupełniające, które może ujawnić błędy, których nigdy nawet nie pomyślałeś szukać?

Witamy w świecie testowania opartego na właściwościach, paradygmacie, który przesuwa nacisk z testowania konkretnych przykładów na weryfikowanie ogólnych właściwości twojego kodu. A w ekosystemie Pythona niekwestionowanym mistrzem tego podejścia jest biblioteka o nazwie Hypothesis.

Ten kompleksowy przewodnik poprowadzi cię od całkowicie początkującego do pewnego praktyka testowania opartego na właściwościach za pomocą Hypothesis. Zbadamy podstawowe koncepcje, zagłębimy się w praktyczne przykłady i nauczymy się, jak zintegrować to potężne narzędzie z codziennym procesem rozwoju, aby tworzyć bardziej solidne, niezawodne i odporne na błędy oprogramowanie.

Czym jest testowanie oparte na właściwościach? Zmiana w sposobie myślenia

Aby zrozumieć Hypothesis, musimy najpierw pojąć fundamentalną ideę testowania opartego na właściwościach. Porównajmy to z tradycyjnym testowaniem opartym na przykładach, które wszyscy znamy.

Testowanie oparte na przykładach: znana ścieżka

Wyobraź sobie, że napisałeś niestandardową funkcję sortowania, my_sort(). Przy testowaniu opartym na przykładach twój proces myślowy byłby następujący:

• "Przetestujmy to za pomocą prostej, uporządkowanej listy." -> assert my_sort([1, 2, 3]) == [1, 2, 3]
• "A co z listą posortowaną w odwrotnej kolejności?" -> assert my_sort([3, 2, 1]) == [1, 2, 3]
• "A co z pustą listą?" -> assert my_sort([]) == []
• "Lista z duplikatami?" -> assert my_sort([5, 1, 5, 2]) == [1, 2, 5, 5]
• "I lista z liczbami ujemnymi?" -> assert my_sort([-1, -5, 0]) == [-5, -1, 0]

To jest skuteczne, ale ma fundamentalne ograniczenie: testujesz tylko przypadki, o których możesz pomyśleć. Twoje testy są tak dobre, jak twoja wyobraźnia. Możesz pominąć przypadki brzegowe z udziałem bardzo dużych liczb, niedokładności zmiennoprzecinkowych, określonych znaków Unicode lub złożonych kombinacji danych, które prowadzą do nieoczekiwanego zachowania.

Testowanie oparte na właściwościach: Myślenie w kategoriach niezmienników

Testowanie oparte na właściwościach odwraca sytuację. Zamiast dostarczać konkretne przykłady, definiujesz właściwości lub niezmienniki swojej funkcji - reguły, które powinny być prawdziwe dla dowolnego prawidłowego wejścia. Dla naszej funkcji my_sort() te właściwości mogą być następujące:

• Wyjście jest posortowane: Dla dowolnej listy liczb każdy element na liście wyjściowej jest mniejszy lub równy następnemu elementowi.
• Wyjście zawiera te same elementy co wejście: Posortowana lista jest tylko permutacją oryginalnej listy; żadne elementy nie są dodawane ani tracone.
• Funkcja jest idempotentna: Sortowanie już posortowanej listy nie powinno jej zmieniać. Oznacza to, że my_sort(my_sort(some_list)) == my_sort(some_list).

W tym podejściu nie piszesz danych testowych. Piszesz reguły. Następnie pozwalasz frameworkowi, takiemu jak Hypothesis, generować setki lub tysiące losowych, różnorodnych i często podstępnych danych wejściowych, aby spróbować udowodnić, że twoje właściwości są błędne. Jeśli znajdzie dane wejściowe, które łamią właściwość, znalazł błąd.

Wprowadzenie do Hypothesis: Twój automatyczny generator danych testowych

Hypothesis to wiodąca biblioteka do testowania opartego na właściwościach dla Pythona. Pobiera zdefiniowane właściwości i wykonuje ciężką pracę związaną z generowaniem danych testowych, aby je zakwestionować. To nie tylko generator losowych danych; to inteligentne i potężne narzędzie zaprojektowane do wydajnego znajdowania błędów.

Kluczowe cechy Hypothesis

• Automatyczne generowanie przypadków testowych: Definiujesz *kształt* potrzebnych danych (np. "lista liczb całkowitych", "ciąg znaków zawierający tylko litery", "data i godzina w przyszłości"), a Hypothesis generuje szeroką gamę przykładów zgodnych z tym kształtem.
• Inteligentne zmniejszanie: To jest magiczna funkcja. Kiedy Hypothesis znajdzie przypadek testowy, który kończy się niepowodzeniem (np. lista 50 liczb zespolonych, która powoduje awarię funkcji sortowania), nie tylko zgłasza tę ogromną listę. Inteligentnie i automatycznie upraszcza dane wejściowe, aby znaleźć najmniejszy możliwy przykład, który nadal powoduje awarię. Zamiast listy 50-elementowej może zgłosić, że awaria występuje tylko z [inf, nan]. To sprawia, że debugowanie jest niezwykle szybkie i wydajne.
• Bezproblemowa integracja: Hypothesis doskonale integruje się z popularnymi frameworkami testowymi, takimi jak pytest i unittest. Możesz dodawać testy oparte na właściwościach obok istniejących testów opartych na przykładach bez zmiany workflow.
• Bogata biblioteka strategii: Zawiera ogromną kolekcję wbudowanych "strategii" do generowania wszystkiego, od prostych liczb całkowitych i ciągów znaków po złożone, zagnieżdżone struktury danych, daty i godziny uwzględniające strefę czasową, a nawet tablice NumPy.
• Testowanie stanowe: W przypadku bardziej złożonych systemów Hypothesis może testować sekwencje działań, aby znaleźć błędy w przejściach stanów, co jest notorycznie trudne w przypadku testowania opartego na przykładach.

Pierwsze kroki: Twój pierwszy test Hypothesis

Zabierzmy się do pracy. Najlepszym sposobem na zrozumienie Hypothesis jest zobaczenie go w akcji.

Instalacja

Najpierw musisz zainstalować Hypothesis i wybrany program uruchamiający testy (użyjemy pytest). To proste jak:

pip install pytest hypothesis

Prosty przykład: Funkcja wartości bezwzględnej

Rozważmy prostą funkcję, która ma obliczać wartość bezwzględną liczby. Nieco błędna implementacja może wyglądać tak:

# w pliku o nazwie `my_math.py`
def custom_abs(x):
    """Niestandardowa implementacja funkcji wartości bezwzględnej."""
    if x < 0:
        return -x
    return x

Teraz napiszmy plik testowy, test_my_math.py. Najpierw tradycyjne podejście pytest:

# test_my_math.py (oparte na przykładach)
def test_abs_positive():
    assert custom_abs(5) == 5

def test_abs_negative():
    assert custom_abs(-5) == 5

def test_abs_zero():
    assert custom_abs(0) == 0

Te testy przechodzą. Nasza funkcja wygląda poprawnie na podstawie tych przykładów. Ale teraz napiszmy test oparty na właściwościach z Hypothesis. Jaka jest podstawowa właściwość funkcji wartości bezwzględnej? Wynik nigdy nie powinien być ujemny.

# test_my_math.py (oparte na właściwościach z Hypothesis)
from hypothesis import given
from hypothesis import strategies as st

from my_math import custom_abs

@given(st.integers())
def test_abs_property_is_non_negative(x):
    """Właściwość: wartość bezwzględna dowolnej liczby całkowitej jest zawsze >= 0."""
    assert custom_abs(x) >= 0

Rozłóżmy to na czynniki pierwsze:

• from hypothesis import given, strategies as st: Importujemy niezbędne komponenty. given to dekorator, który zamienia zwykłą funkcję testową w test oparty na właściwościach. strategies to moduł, w którym znajdujemy nasze generatory danych.
• @given(st.integers()): To jest sedno testu. Dekorator @given mówi Hypothesis, aby uruchomił tę funkcję testową wiele razy. Dla każdego uruchomienia wygeneruje wartość za pomocą dostarczonej strategii, st.integers() i przekaże ją jako argument x do naszej funkcji testowej.
• assert custom_abs(x) >= 0: To jest nasza właściwość. Twierdzimy, że dla jakiejkolwiek liczby całkowitej x, o której Hypothesis marzy, wynik naszej funkcji musi być większy lub równy zero.

Kiedy uruchomisz to za pomocą pytest, prawdopodobnie przejdzie dla wielu wartości. Hypothesis spróbuje 0, -1, 1, dużych liczb dodatnich, dużych liczb ujemnych i nie tylko. Nasza prosta funkcja obsługuje wszystkie te poprawnie. Teraz spróbujmy innej strategii, aby sprawdzić, czy możemy znaleźć słabość.

# Przetestujmy z liczbami zmiennoprzecinkowymi
@given(st.floats())
def test_abs_floats_property(x):
    assert custom_abs(x) >= 0

Jeśli to uruchomisz, Hypothesis szybko znajdzie przypadek niepowodzenia!

Falsifying example: test_abs_floats_property(x=nan)
... 
assert custom_abs(nan) >= 0
AssertionError: assert nan >= 0

Hypothesis odkrył, że nasza funkcja, gdy otrzyma float('nan') (Not a Number), zwraca nan. Asercja nan >= 0 jest fałszywa. Właśnie znaleźliśmy subtelny błąd, o którym prawdopodobnie nie pomyślelibyśmy, aby przetestować go ręcznie. Moglibyśmy naprawić naszą funkcję, aby obsłużyć ten przypadek, być może poprzez wywołanie ValueError lub zwrócenie określonej wartości.

Jeszcze lepiej, co jeśli błąd dotyczyłby bardzo specyficznej liczby zmiennoprzecinkowej? Reduktor Hypothesis wziąłby dużą, złożoną liczbę powodującą błąd i zredukował ją do najprostszej możliwej wersji, która nadal wyzwala błąd.

Potęga strategii: Tworzenie danych testowych

Strategie są sercem Hypothesis. Są to przepisy na generowanie danych. Biblioteka zawiera ogromną gamę wbudowanych strategii i możesz je łączyć i dostosowywać, aby generować praktycznie dowolną strukturę danych, jaką możesz sobie wyobrazić.

Typowe wbudowane strategie

• Numeryczne:
  • st.integers(min_value=0, max_value=1000): Generuje liczby całkowite, opcjonalnie w określonym zakresie.
  • st.floats(min_value=0.0, max_value=1.0, allow_nan=False, allow_infinity=False): Generuje liczby zmiennoprzecinkowe z precyzyjną kontrolą nad wartościami specjalnymi.
  • st.fractions(), st.decimals()
• Tekst:
  • st.text(min_size=1, max_size=50): Generuje ciągi Unicode o określonej długości.
  • st.text(alphabet='abcdef0123456789'): Generuje ciągi znaków z określonego zestawu znaków (np. dla kodów szesnastkowych).
  • st.characters(): Generuje pojedyncze znaki.
• Kolekcje:
  • st.lists(st.integers(), min_size=1): Generuje listy, w których każdy element jest liczbą całkowitą. Zwróć uwagę, jak przekazujemy inną strategię jako argument! Nazywa się to kompozycją.
  • st.tuples(st.text(), st.booleans()): Generuje krotki o stałej strukturze.
  • st.sets(st.integers())
  • st.dictionaries(keys=st.text(), values=st.integers()): Generuje słowniki z określonymi typami kluczy i wartości.
• Temporalne:
  • st.dates(), st.times(), st.datetimes(), st.timedeltas(). Można je uwzględniać w strefie czasowej.
• Różne:
  • st.booleans(): Generuje True lub False.
  • st.just('constant_value'): Zawsze generuje tę samą pojedynczą wartość. Przydatne do tworzenia złożonych strategii.
  • st.one_of(st.integers(), st.text()): Generuje wartość z jednej z dostarczonych strategii.
  • st.none(): Generuje tylko None.

Łączenie i przekształcanie strategii

Prawdziwa moc Hypothesis wynika z jego zdolności do budowania złożonych strategii z prostszych.

Używanie .map()

Metoda .map() pozwala pobrać wartość z jednej strategii i przekształcić ją w coś innego. Jest to idealne rozwiązanie do tworzenia obiektów niestandardowych klas.

# Prosta klasa danych
from dataclasses import dataclass

@dataclass
class User:
    user_id: int
    username: str

# Strategia generowania obiektów User
user_strategy = st.builds(
    User,
    user_id=st.integers(min_value=1),
    username=st.text(min_size=3, alphabet='abcdefghijklmnopqrstuvwxyz')
)

@given(user=user_strategy)
def test_user_creation(user):
    assert isinstance(user, User)
    assert user.user_id > 0
    assert user.username.isalpha()

Używanie .filter() i assume()

Czasami trzeba odrzucić niektóre wygenerowane wartości. Na przykład możesz potrzebować listy liczb całkowitych, w której suma nie wynosi zero. Możesz użyć .filter():

st.lists(st.integers()).filter(lambda x: sum(x) != 0)

Jednak używanie .filter() może być nieefektywne. Jeśli warunek jest często fałszywy, Hypothesis może spędzić dużo czasu na próbach wygenerowania prawidłowego przykładu. Lepszym podejściem jest często użycie assume() wewnątrz funkcji testowej:

from hypothesis import assume

@given(st.lists(st.integers()))
def test_something_with_non_zero_sum_list(numbers):
    assume(sum(numbers) != 0)
    # ... logika testu tutaj ...

assume() mówi Hypothesis: "Jeśli ten warunek nie jest spełniony, po prostu odrzuć ten przykład i spróbuj nowego." Jest to bardziej bezpośredni i często wydajniejszy sposób ograniczania danych testowych.

Używanie st.composite()

W przypadku naprawdę złożonego generowania danych, gdzie jedna wygenerowana wartość zależy od innej, st.composite() jest narzędziem, którego potrzebujesz. Pozwala napisać funkcję, która przyjmuje specjalną funkcję draw jako argument, której można użyć do pobierania wartości z innych strategii krok po kroku.

Klasycznym przykładem jest generowanie listy i prawidłowego indeksu do tej listy.

@st.composite
def list_and_index(draw):
    # Najpierw narysuj niepustą listę
    my_list = draw(st.lists(st.integers(), min_size=1))
    # Następnie narysuj indeks, który z pewnością będzie prawidłowy dla tej listy
    index = draw(st.integers(min_value=0, max_value=len(my_list) - 1))
    return (my_list, index)

@given(data=list_and_index())
def test_list_access(data):
    my_list, index = data
    # Ten dostęp jest gwarantowany jako bezpieczny ze względu na sposób, w jaki zbudowaliśmy strategię
    element = my_list[index]
    assert element is not None # Prosta asercja

Hypothesis w akcji: Scenariusze z życia wzięte

Zastosujmy te koncepcje do bardziej realistycznych problemów, z którymi programiści borykają się każdego dnia.

Scenariusz 1: Testowanie funkcji serializacji danych

Wyobraź sobie funkcję, która serializuje profil użytkownika (słownik) do ciągu znaków bezpiecznego dla adresów URL i inną, która go deserializuje. Kluczową właściwością jest to, że proces powinien być idealnie odwracalny.

import json
import base64

def serialize_profile(data: dict) -> str:
    """Serializuje słownik do ciągu znaków base64 bezpiecznego dla adresów URL."""
    json_string = json.dumps(data)
    return base64.urlsafe_b64encode(json_string.encode('utf-8')).decode('utf-8')

def deserialize_profile(encoded_str: str) -> dict:
    """Deserializuje ciąg znaków z powrotem do słownika."""
    json_string = base64.urlsafe_b64decode(encoded_str.encode('utf-8')).decode('utf-8')
    return json.loads(json_string)

# Teraz test
# Potrzebujemy strategii, która generuje słowniki kompatybilne z JSON
json_dictionaries = st.dictionaries(
    keys=st.text(),
    values=st.recursive(st.none() | st.booleans() | st.floats(allow_nan=False) | st.text(),
                      lambda children: st.lists(children) | st.dictionaries(st.text(), children),
                      max_leaves=10)
)

@given(profile=json_dictionaries)
def test_serialization_roundtrip(profile):
    """Właściwość: Deserializacja zakodowanego profilu powinna zwrócić oryginalny profil."""
    encoded = serialize_profile(profile)
    decoded = deserialize_profile(encoded)
    assert profile == decoded

Ten pojedynczy test zaatakuje nasze funkcje ogromną różnorodnością danych: puste słowniki, słowniki z zagnieżdżonymi listami, słowniki ze znakami Unicode, słowniki z dziwnymi kluczami i nie tylko. Jest to znacznie dokładniejsze niż pisanie kilku ręcznych przykładów.

Scenariusz 2: Testowanie algorytmu sortowania

Wróćmy do naszego przykładu sortowania. Oto jak przetestować właściwości, które zdefiniowaliśmy wcześniej.

from collections import Counter

def my_buggy_sort(numbers):
    # Wprowadźmy subtelny błąd: pomija duplikaty
    return sorted(list(set(numbers)))

@given(st.lists(st.integers()))
def test_sorting_properties(numbers):
    sorted_list = my_buggy_sort(numbers)

    # Właściwość 1: Wyjście jest posortowane
    for i in range(len(sorted_list) - 1):
        assert sorted_list[i] <= sorted_list[i+1]

    # Właściwość 2: Elementy są takie same (to znajdzie błąd)
    assert Counter(numbers) == Counter(sorted_list)

    # Właściwość 3: Funkcja jest idempotentna
    assert my_buggy_sort(sorted_list) == sorted_list

Kiedy uruchomisz ten test, Hypothesis szybko znajdzie przypadek niepowodzenia dla Właściwości 2, na przykład numbers=[0, 0]. Nasza funkcja zwraca [0], a Counter([0, 0]) nie równa się Counter([0]). Reduktor zapewni, że przykład niepowodzenia jest tak prosty, jak to możliwe, dzięki czemu przyczyna błędu będzie od razu oczywista.

Scenariusz 3: Testowanie stanowe

W przypadku obiektów ze stanem wewnętrznym, który zmienia się w czasie (takich jak połączenie z bazą danych, koszyk na zakupy lub pamięć podręczna), znalezienie błędów może być niezwykle trudne. Do wyzwolenia błędu może być wymagana określona sekwencja operacji. Hypothesis udostępnia RuleBasedStateMachine dokładnie do tego celu.

Wyobraź sobie proste API dla wbudowanego magazynu klucz-wartość:

class SimpleKeyValueStore:
    def __init__(self):
        self._data = {}
    def set(self, key, value):
        self._data[key] = value
    def get(self, key):
        return self._data.get(key)
    def delete(self, key):
        if key in self._data:
            del self._data[key]
    def size(self):
        return len(self._data)

Możemy modelować jego zachowanie i testować je za pomocą automatu stanów:

from hypothesis.stateful import RuleBasedStateMachine, rule, Bundle

class KeyValueStoreMachine(RuleBasedStateMachine):
    def __init__(self):
        super().__init__()
        self.model = {}
        self.sut = SimpleKeyValueStore()

    # Bundle() służy do przekazywania danych między regułami
    keys = Bundle('keys')

    @rule(target=keys, key=st.text(), value=st.integers())
    def set_key(self, key, value):
        self.model[key] = value
        self.sut.set(key, value)
        return key

    @rule(key=keys)
    def delete_key(self, key):
        del self.model[key]
        self.sut.delete(key)

    @rule(key=st.text())
    def get_key(self, key):
        model_val = self.model.get(key)
        sut_val = self.sut.get(key)
        assert model_val == sut_val

    @rule()
    def check_size(self):
        assert len(self.model) == self.sut.size()

# Aby uruchomić test, po prostu dziedzicz po maszynie i unittest.TestCase
# W pytest możesz po prostu przypisać test do klasy maszyny
TestKeyValueStore = KeyValueStoreMachine.TestCase

Hypothesis wykona teraz losowe sekwencje operacji set_key, delete_key, get_key i check_size, nieustannie próbując znaleźć sekwencję, która spowoduje niepowodzenie jednej z asercji. Sprawdzi, czy pobieranie usuniętego klucza zachowuje się poprawnie, czy rozmiar jest spójny po wielu ustawieniach i usunięciach oraz wiele innych scenariuszy, o których możesz nie pomyśleć, aby przetestować je ręcznie.

Najlepsze praktyki i zaawansowane wskazówki

• Baza danych przykładów: Hypothesis jest sprytny. Kiedy znajdzie błąd, zapisuje przykład niepowodzenia w lokalnym katalogu (.hypothesis/). Następnym razem, gdy uruchomisz testy, najpierw odtworzy ten przykład niepowodzenia, dając ci natychmiastową informację, że błąd nadal występuje. Po naprawieniu przykład nie jest już odtwarzany.
• Kontrolowanie wykonywania testów za pomocą @settings: Możesz kontrolować wiele aspektów uruchomienia testu za pomocą dekoratora @settings. Możesz zwiększyć liczbę przykładów, ustawić termin, jak długo może działać pojedynczy przykład (aby wyłapać nieskończone pętle) i wyłączyć niektóre kontrole stanu.

  @settings(max_examples=500, deadline=1000) # Uruchom 500 przykładów, 1-sekundowy termin
  @given(...) ...

• Odtwarzanie błędów: Każde uruchomienie Hypothesis wypisuje wartość początkową (np. @reproduce_failure('version', 'seed')). Jeśli serwer CI znajdzie błąd, którego nie możesz odtworzyć lokalnie, możesz użyć tego dekoratora z dostarczoną wartością początkową, aby wymusić na Hypothesis uruchomienie dokładnie tej samej sekwencji przykładów.
• Integracja z CI/CD: Hypothesis idealnie pasuje do dowolnego potoku ciągłej integracji. Jego zdolność do znajdowania niejasnych błędów, zanim dotrą one do produkcji, czyni go nieocenioną siatką bezpieczeństwa.

Zmiana nastawienia: Myślenie w kategoriach właściwości

Wdrażanie Hypothesis to coś więcej niż tylko nauka nowej biblioteki; chodzi o przyjęcie nowego sposobu myślenia o poprawności kodu. Zamiast pytać: "Jakie dane wejściowe powinienem przetestować?", zaczynasz pytać: "Jakie są uniwersalne prawdy o tym kodzie?"

Oto kilka pytań, które pomogą ci w identyfikacji właściwości:

• Czy istnieje operacja odwrotna? (np. serializacja/deserializacja, szyfrowanie/deszyfrowanie, kompresja/dekompresja). Właściwością jest to, że wykonanie operacji i jej odwrotności powinno dać oryginalne dane wejściowe.
• Czy operacja jest idempotentna? (np. abs(abs(x)) == abs(x)). Zastosowanie funkcji więcej niż raz powinno dać taki sam wynik, jak zastosowanie jej raz.
• Czy istnieje inny, prostszy sposób obliczenia tego samego wyniku? Możesz sprawdzić, czy twoja złożona, zoptymalizowana funkcja daje takie samo wyjście, jak prosta, oczywista wersja (np. testowanie twojego fantazyjnego sortowania względem wbudowanego w Pythona sorted()).
• Co powinno być zawsze prawdą o wyjściu? (np. wyjście funkcji find_prime_factors powinno zawierać tylko liczby pierwsze, a ich iloczyn powinien być równy wejściu).
• Jak zmienia się stan? (W przypadku testowania stanowego) Jakie niezmienniki muszą być utrzymywane po każdej prawidłowej operacji? (np. liczba pozycji w koszyku na zakupy nigdy nie może być ujemna).

Wniosek: Nowy poziom pewności

Testowanie oparte na właściwościach z Hypothesis nie zastępuje testowania opartego na przykładach. Nadal potrzebujesz konkretnych, ręcznie pisanych testów dla krytycznej logiki biznesowej i dobrze zrozumiałych wymagań (np. "Użytkownik z kraju X musi widzieć cenę Y").

To, co zapewnia Hypothesis, to potężny, zautomatyzowany sposób eksploracji zachowania twojego kodu i ochrony przed nieprzewidzianymi przypadkami brzegowymi. Działa jako niestrudzony partner, generując tysiące testów, które są bardziej różnorodne i podstępne niż jakikolwiek człowiek mógłby realistycznie napisać. Definiując fundamentalne właściwości twojego kodu, tworzysz solidną specyfikację, z którą Hypothesis może testować, dając ci nowy poziom pewności w twoim oprogramowaniu.

Następnym razem, gdy napiszesz funkcję, poświęć chwilę, aby pomyśleć poza przykładami. Zapytaj siebie: "Jakie są zasady? Co musi być zawsze prawdą?" Następnie pozwól Hypothesis wykonać ciężką pracę związaną z próbą ich złamania. Będziesz zaskoczony tym, co znajdzie, a twój kod będzie lepszy dzięki temu.